let { User, Message, Comment } = require('../models');
const auth = require('../utils/auth');
let default_fn = async (ctx, next) => {
    ctx.render('index.html')
}
// 显示首页
let index_fn = async (ctx, next) => {
    let username = ctx.session.userName;
    let userIds = [];
    // 所有的说说
    let msgs = JSON.parse(JSON.stringify(await Message.findAll({
        order: [
            ['id', 'desc']
        ]
    })));

    // 查询出来的说说的id（如果有分页，则应该是10条说说的id）
    let msgIds = [];

    msgs.forEach(item => {
        msgIds.push(item.id);
        userIds.push(item.fromUserId);
    });


    // 所有的吐槽（如果有分页，可以根据查出来的说说的id，来查询所对应的所有的吐槽）
    let comments = JSON.parse(JSON.stringify(await Comment.findAll({
        where: {
            msgId: msgIds
        }
    })));

    comments.forEach(item => {
        userIds.push(item.fromUserId);
    });

    let userAll = await User.findAll({
        where: {
            id: userIds
        }
    });

    // 遍历所有的评论，给每一个评论的fromUserId加上用户名称
    comments.forEach(item => {
        let userInfo = userAll.filter(row => {
            return item.fromUserId === row.id;
        })[0];
        item.comUserName = userInfo === undefined ? '匿名' : userInfo.username;
    })

    // 组合成上下级关系
    msgs.forEach(msg => {
        let sayComments = comments.filter(item => {
            return item.msgId === msg.id;
        });
        let userInfo = userAll.filter(row => {
            return msg.fromUserId === row.id;
        })[0];
        msg.msgUserName = userInfo === undefined ? '匿名' : userInfo.username;
        msg.comments = sayComments;
    })


    let obj = {
        username,
        msgs
    };
    ctx.render('index.html', obj);
};


// 显示登录界面
let login_fn = async (ctx, next) => {
    ctx.render('login.html');
};

// 两个登录成功后的管理界面

let user_messages_fn = async (ctx, next) => {
    ctx.render('./messages/user_index.html');
}

let admin_messages_fn = async (ctx, next) => {
    ctx.render('./messages/admin_index.html');
}

// 用户登录界面
let user_login_fn = async (ctx, next) => {
    ctx.render('./user/login.html');
}

// 管理员登录界面
let admin_login_fn = async (ctx, next) => {
    ctx.render('./admin/login.html');
}

// 用户注册界面
let user_register_fn = async (ctx, next) => {
    ctx.render('./user/register.html')
}

// 管理员注册界面
let admin_register_fn = async (ctx, next) => {
    ctx.render('./admin/register.html');
}

// 用户忘记界面
let user_forget_fn = async (ctx, next) => {
    ctx.render('./user/forget.html');
}

// 管理员忘记界面
let admin_forger_fn = async (ctx, next) => {
    ctx.render('./admin/forget.html');
}

// 处理登录请求
let loginDone_fn = async (ctx, next) => {
    // 获取从前端传来的数据（用户信息）
    let uid = ctx.request.body.username.trim() || '';
    let pwd = ctx.request.body.password.trim() || '';

    let res = '';

    if (uid.length > 0 && pwd.length > 0) {
        let row = await User.findOne({
            where: {
                username: uid,
                password: pwd
            }
        });
        let u2Json = JSON.stringify(row);
        if (u2Json !== 'null') {
            ctx.session.userId = row.id;
            ctx.session.userName = row.username;
            res = { code: 200, msg: '登录成功' };
        } else {
            res = { code: 1000, msg: '用户名或密码错误，请确认后重试' };
        }

    } else {
        res = { code: 1000, msg: '用户名和密码不能为空' };
    }
    ctx.body = JSON.stringify(res);
};

// 处理注册请求
let registerDone_fn = async (ctx, next) => {
    // 获取从前端传来的数据（用户信息）
    let uid = ctx.request.body.username.trim() || '';
    let pwd = ctx.request.body.password.trim() || '';
    let confirmpwd = ctx.request.body.confirmpassword.trim() || '';

    let res = '';

    // 判断用户名、密码是否为空，为空则返回提示信息；不为空则尝试从数据库中查询是否有同名用户，如果没有，则创建用户；如果有，则返回提示信息；
    // 初步尝试then的玩法，出现了一些顺序问题（前端获取的返回数据为空的情况）
    if (uid.length > 0 && pwd.length > 0 && pwd === confirmpwd) {
        let row = await User.findOne({
            where: {
                username: uid
            }
        });
        let u2Json = JSON.stringify(row);
        if (u2Json === 'null') {
            let u1 = await User.create({
                username: uid,
                password: pwd
            });
            let u1Json = JSON.stringify(u1);
            if (u1Json !== 'null') {
                res = { code: 200, msg: '用户注册成功' };
            } else {
                res = { code: 1000, msg: '因为服务器或者网络原因，用户未注册成功' };
            }
        } else {
            res = { code: 1000, msg: '当前用户名已经注册，请确认后重试' };
        }
    } else {
        res = { code: 1000, msg: '用户名和密码不能为空，且两密码应该一致' };
    }
    // 返回消息
    ctx.body = JSON.stringify(res);
};

// 注销
let logout_fn = async (ctx, next) => {
    ctx.session = null;
    ctx.body = { code: 200, msg: '注销成功' };
}

// 说说调用的方法
let say_fn = async (ctx, next) => {
    let sayMsg = ctx.request.body.sayMsg || '';
    let userId = ctx.session.userId;
    let say = await Message.create({
        fromUserId: userId,
        content: sayMsg
    });

    let data = JSON.stringify(say);

    ctx.body = { code: 200, data, msg: '发表说说成功' };
}

// 吐槽一下调用的方法
let comment_fn = async (ctx, next) => {
    let commentMsg = ctx.request.body.commentMsg || '';
    let msgId = ctx.request.body.msgId || '';
    let fromUserId = ctx.session.userId;

    // 将评论的信息插入数据库
    let comment = await Comment.create({
        fromUserId: fromUserId,
        msgId: msgId,
        content: commentMsg
    });

    // 因为要查找说说的用户信息，所以这里先查询了说说的信息，拿到发表说说的用户的id
    let msg = await Message.findOne({
        where: {
            id: msgId
        }
    });

    let toUserId = msg === undefined ? '0' : msg.fromUserId;

    // 在用户表里查询发表说说的用户的信息和发表评论的用户的信息
    let users = await User.findAll({
        where: {
            id: [fromUserId, toUserId]
        }
    });

    // 根据评论者的id，查询到说说的用户信息
    var fromUserInfo = JSON.parse(JSON.stringify(users.filter(user => {
        return user.id === fromUserId;
    })[0]));

    // 根据发表说说的id，查询到评论的用户信息
    var toUserInfo = JSON.parse(JSON.stringify(users.filter(user => {
        return user.id === toUserId;
    })[0]));


    let data = JSON.parse(JSON.stringify(comment));

    // 将说说的用户名称和评论的用户名称挂载到数据信息里面，返回前端
    data.fromUserName = fromUserInfo.username;
    data.toUserName = toUserInfo.username;

    ctx.body = { code: 200, data, msg: '吐槽成功' };
}

module.exports = {
    // 显示首页
    '/': ['get', auth, index_fn],
    
    // 登陆分支
    '/login': ['get', auth, login_fn],

    // 注销
    '/logout': ['post', auth, logout_fn],

    // 登录界面
    '/userLogin': ['get', user_login_fn],
    '/adminLogin': ['get', admin_login_fn],

    // 主页分支
    '/userMessage': ['get', user_messages_fn],
    '/adminMessage': ['get', admin_messages_fn],

    // 注册界面
    '/userRegister': ['get', user_register_fn],
    '/adminRegister': ['get', admin_register_fn],

    // 忘记界面
    '/userForget': ['get', user_forget_fn],
    '/adminForget': ['get', admin_forger_fn],

    // 验证部分
    '/loginDone': ['post', loginDone_fn],
    '/registerDone': ['post', registerDone_fn],

    // 功能调用方法
    '/say': ['post', say_fn],
    '/comment': ['post', comment_fn],
}